/**
 * 替换一位数的话：0~9，对于abcd*e来说，
 * 如果(a + b + c + d + e) % 3 == 0，则abcd0e, abcd3e, abcd6e必可被3整除，这样只替换一位数的话，最多只能有7个素数
 * 如果(a + b + c + d + e) % 3 == 1，则abcd2e, abcd5e, abcd8e必可被3整除，这样只替换一位数的话，最多只能有7个素数
 * 如果(a + b + c + d + e) % 3 == 2，则abcd1e, abcd4e, abcd7e必可被3整除，这样只替换一位数的话，最多只能有7个素数
 * 
 * 替换两位数的话：0~9，对于abc**d来说，
 * 如果(a + b + c + d) % 3 == 0，则abc00d, abc33d, abc66d必可被3整除，这样只替换两位数的话，最多只能有7个素数
 * 如果(a + b + c + d) % 3 == 1，则abc11d, abc44d, abc77d必可被3整除，这样只替换两位数的话，最多只能有7个素数
 * 如果(a + b + c + d) % 3 == 2，则abc22d, abc55d, abc88d必可被3整除，这样只替换两位数的话，最多只能有7个素数
 * 
 * 运用类似的方法可分析出要替换的数是四位数、五位数均不可能。所以不妨从三位数开始。
 */

#include <iostream>
#include <vector>

using namespace std;

static bool prime(uint64_t n) {
    if (n < 2)
        return false;
    if (n == 2)
        return true;
    if (n % 2 == 0)
        return false;
    if (n == 5)
        return true;
    if (n % 5 == 0)
        return false;

    for (uint64_t i = 3; i * i <= n; i += 2) {
        if (n % i == 0)
            return false;
    }

    return true;
}

static bool three_same_digits(const vector<unsigned>v, vector<unsigned>& index) {
    vector<unsigned> d(10);
    for (auto i = 1; i < v.size(); ++i) {
        ++d[v[i]];
        if (d[v[i]] == 3)
            break;
    }
    unsigned f = -1;
    for (int i = 0; i < d.size(); ++i) {
        if (d[i] == 3) {
            f = i;
            break;
        }
    }
    for (int i = 1; i < v.size(); ++i) {
        if (v[i] == f)
            index.push_back(i);
    }
    return index.size() >= 3;
}

static vector<uint64_t> replace(vector<unsigned> v, const vector<unsigned>& i) {
    vector<uint64_t> r;
    for (int j = 0; j < 10; ++j) {
        v[i[0]] = j;
        v[i[1]] = j;
        v[i[2]] = j;
        uint64_t t = 0;
        for (int k = v.size() - 1; k >= 0; --k)
            t = 10 * t + v[k];
        if (v.back() && prime(t))
            r.push_back(t);
    }
    return r;
}

static vector<uint64_t> fuck(uint64_t num) {
    if (!prime(num))
        return {};

    vector<unsigned> i;
    vector<unsigned> v;
    while (num) {
        v.push_back(num % 10);
        num /= 10;
    }
    
    if (!three_same_digits(v, i))
        return {};
 
    return replace(v, i);
}

int main() {
    for (uint64_t i = 1000; ; ++i) {
        vector<uint64_t> v = fuck(i);
        if (v.size() >= 8) {
            for (auto e : v)
                cout << e << endl;
            break;
        }
    }
}